import React from 'react'
import ReactDOM from 'react-dom/client'
import { BrowserRouter as Router, Routes, Route, Navigate } from 'react-router-dom'
import './index.css'

// 导入数据初始化函数
import { initializeData } from './shared/utils/init'

//开发环境使用
// 在main.tsx中添加测试方法暴露到全局

import { POST_register, POST_login, POST_logout } from './shared/api/auth';

// 仅在开发环境暴露测试API
if (process.env.NODE_ENV === 'development') {
  (window as any).testAPI = {
    // 认证相关API测试
    auth: {
      register: POST_register,
      login: POST_login,
      logout: POST_logout
    }
  };

  // 便捷的测试函数
  (window as any).testAuth = {
    // 测试注册
    testRegister: async () => {
      const testData = {
        username: "testuser123",
        email: `test${Date.now()}@example.com`,
        phone: "13800138" + String(Date.now()).slice(-3),
        password: "123456"
      };

      console.log('测试注册数据:', testData);
      const result = await POST_register(testData);
      console.log('注册结果:', result);
      return result;
    },

    // 测试用管理员账号登录
    testLoginAdmin: async () => {
      const testData = {
        usernameOrEmail: "admin",
        password: "123456"  // 注意：这个密码要和初始数据中admin用户的密码匹配
      };

      console.log('测试管理员登录数据:', testData);
      const result = await POST_login(testData);
      console.log('登录结果:', result);
      return result;
    },

    // 测试用普通用户登录
    testLoginUser: async () => {
      const testData = {
        usernameOrEmail: "张三",
        password: "123456"  // 注意：这个密码要和初始数据中张三的密码匹配
      };

      console.log('测试普通用户登录数据:', testData);
      const result = await POST_login(testData);
      console.log('登录结果:', result);
      return result;
    },

    // 测试用邮箱登录
    testLoginByEmail: async () => {
      const testData = {
        usernameOrEmail: "admin@mall.com",
        password: "123456"
      };

      console.log('测试邮箱登录数据:', testData);
      const result = await POST_login(testData);
      console.log('登录结果:', result);
      return result;
    },

    // 测试登出
    testLogout: async () => {
      console.log('测试登出...');
      const result = await POST_logout();
      console.log('登出结果:', result);
      return result;
    },

    // 测试错误场景
    testLoginErrors: async () => {
      console.log('=== 测试登录错误场景 ===');

      // 测试用户不存在
      console.log('1. 测试用户不存在...');
      let result = await POST_login({
        usernameOrEmail: "nonexistent",
        password: "123456"
      });
      console.log('结果:', result);

      // 测试密码错误
      console.log('2. 测试密码错误...');
      result = await POST_login({
        usernameOrEmail: "admin",
        password: "wrongpassword"
      });
      console.log('结果:', result);

      // 测试参数缺失
      console.log('3. 测试参数缺失...');
      result = await POST_login({
        usernameOrEmail: "",
        password: "123456"
      });
      console.log('结果:', result);
    }
  };
}

// 在main.tsx中添加用户API测试方法

import {
  GET_profile,
  PUT_profile,
  GET_addresses,
  POST_address,
  DELETE_address,
  GET_admin_users,
  PUT_admin_permission
} from './shared/api/user';

// 在开发环境中扩展测试API
if (process.env.NODE_ENV === 'development') {
  // 扩展现有的testAPI对象
  (window as any).testAPI = {
    ...(window as any).testAPI,
    // 用户相关API测试
    user: {
      getProfile: GET_profile,
      updateProfile: PUT_profile,
      getAddresses: GET_addresses,
      addAddress: POST_address,
      deleteAddress: DELETE_address,
      // 管理员功能
      getAllUsers: GET_admin_users,
      updateUserPermission: PUT_admin_permission
    }
  };

  // 扩展便捷测试函数
  (window as any).testUser = {
    // 测试获取用户信息
    testGetProfile: async () => {
      console.log('=== 测试获取用户信息 ===');
      const result = await GET_profile();
      console.log('结果:', result);
      return result;
    },

    // 测试更新用户信息
    testUpdateProfile: async () => {
      console.log('=== 测试更新用户信息 ===');
      const testData = {
        username: "updated_user_" + Date.now(),
        email: `updated${Date.now()}@example.com`,
        phone: "13900139" + String(Date.now()).slice(-3)
      };

      console.log('更新数据:', testData);
      const result = await PUT_profile(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试部分更新用户信息
    testPartialUpdate: async () => {
      console.log('=== 测试部分更新用户信息 ===');
      const testData = {
        username: "partial_" + Date.now()
      };

      console.log('更新数据:', testData);
      const result = await PUT_profile(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试获取地址列表
    testGetAddresses: async () => {
      console.log('=== 测试获取地址列表 ===');
      const result = await GET_addresses();
      console.log('结果:', result);
      return result;
    },

    // 测试添加地址
    testAddAddress: async () => {
      console.log('=== 测试添加地址 ===');
      const testData = {
        receiverName: "张三丰",
        phone: "13888888888",
        fullAddress: "北京市朝阳区三里屯SOHO 3号楼 1001室"
      };

      console.log('地址数据:', testData);
      const result = await POST_address(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试删除地址（需要先有地址ID）
    testDeleteAddress: async (addressId?: string) => {
      console.log('=== 测试删除地址 ===');

      if (!addressId) {
        // 如果没有提供地址ID，先获取地址列表
        console.log('未提供地址ID，先获取地址列表...');
        const addressResult = await GET_addresses();
        if (addressResult.code === 200 && addressResult.data?.addresses.length > 0) {
          addressId = addressResult.data.addresses[0].id;
          console.log('使用第一个地址ID:', addressId);
        } else {
          console.log('没有可删除的地址');
          return { code: 400, message: '没有可删除的地址' };
        }
      }

      console.log('删除地址ID:', addressId);
      const result = await DELETE_address(addressId);
      console.log('结果:', result);
      return result;
    },

    // 测试错误场景
    testUserErrors: async () => {
      console.log('=== 测试用户操作错误场景 ===');

      // 测试更新信息错误
      console.log('1. 测试无效邮箱格式...');
      let result = await PUT_profile({
        email: "invalid-email"
      });
      console.log('结果:', result);

      console.log('2. 测试用户名太短...');
      result = await PUT_profile({
        username: "a"
      });
      console.log('结果:', result);

      console.log('3. 测试添加地址缺少字段...');
      result = await POST_address({
        receiverName: "",
        phone: "13888888888",
        fullAddress: "北京市朝阳区"
      });
      console.log('结果:', result);

      console.log('4. 测试删除不存在的地址...');
      result = await DELETE_address("nonexistent_id");
      console.log('结果:', result);
    },

    // 完整流程测试
    testCompleteFlow: async () => {
      console.log('=== 测试用户完整操作流程 ===');

      // 1. 获取用户信息
      console.log('1. 获取用户信息...');
      let result = await GET_profile();
      console.log('用户信息:', result);

      // 2. 更新用户信息
      console.log('2. 更新用户信息...');
      result = await PUT_profile({
        username: "flow_test_" + Date.now()
      });
      console.log('更新结果:', result);

      // 3. 添加地址
      console.log('3. 添加地址...');
      result = await POST_address({
        receiverName: "测试收货人",
        phone: "13999999999",
        fullAddress: "测试地址 " + Date.now()
      });
      console.log('添加地址结果:', result);
      const newAddressId = result.data?.address?.id;

      // 4. 获取地址列表
      console.log('4. 获取地址列表...');
      result = await GET_addresses();
      console.log('地址列表:', result);

      // 5. 删除刚添加的地址
      if (newAddressId) {
        console.log('5. 删除刚添加的地址...');
        result = await DELETE_address(newAddressId);
        console.log('删除结果:', result);
      }

      console.log('=== 完整流程测试结束 ===');
    }
  };

  // 管理员功能测试
  (window as any).testAdmin = {
    // 测试获取所有用户
    testGetAllUsers: async () => {
      console.log('=== 测试获取所有用户列表 ===');
      const result = await GET_admin_users();
      console.log('结果:', result);
      return result;
    },

    // 测试设置用户为管理员
    testSetUserAdmin: async (userId?: string) => {
      console.log('=== 测试设置用户为管理员 ===');

      if (!userId) {
        // 先获取用户列表，找一个普通用户
        const usersResult = await GET_admin_users();
        if (usersResult.code === 200 && usersResult.data?.users.length > 0) {
          const normalUser = usersResult.data.users.find(u => !u.isAdmin);
          if (normalUser) {
            userId = normalUser.id;
            console.log('使用用户:', normalUser.username, '(ID:', userId, ')');
          } else {
            console.log('没有找到普通用户');
            return { code: 400, message: '没有找到普通用户' };
          }
        } else {
          console.log('获取用户列表失败');
          return usersResult;
        }
      }

      const testData = {
        userId: userId!,
        isAdmin: true
      };

      console.log('设置数据:', testData);
      const result = await PUT_admin_permission(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试封禁用户
    testBanUser: async (userId?: string) => {
      console.log('=== 测试封禁用户 ===');

      if (!userId) {
        // 先获取用户列表，找一个未封禁的用户
        const usersResult = await GET_admin_users();
        if (usersResult.code === 200 && usersResult.data?.users.length > 0) {
          const activeUser = usersResult.data.users.find(u => !u.isBanned && !u.isAdmin);
          if (activeUser) {
            userId = activeUser.id;
            console.log('使用用户:', activeUser.username, '(ID:', userId, ')');
          } else {
            console.log('没有找到可封禁的普通用户');
            return { code: 400, message: '没有找到可封禁的普通用户' };
          }
        } else {
          console.log('获取用户列表失败');
          return usersResult;
        }
      }

      const testData = {
        userId: userId!,
        isBanned: true
      };

      console.log('封禁数据:', testData);
      const result = await PUT_admin_permission(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试解封用户
    testUnbanUser: async (userId?: string) => {
      console.log('=== 测试解封用户 ===');

      if (!userId) {
        // 先获取用户列表，找一个被封禁的用户
        const usersResult = await GET_admin_users();
        if (usersResult.code === 200 && usersResult.data?.users.length > 0) {
          const bannedUser = usersResult.data.users.find(u => u.isBanned);
          if (bannedUser) {
            userId = bannedUser.id;
            console.log('使用用户:', bannedUser.username, '(ID:', userId, ')');
          } else {
            console.log('没有找到被封禁的用户');
            return { code: 400, message: '没有找到被封禁的用户' };
          }
        } else {
          console.log('获取用户列表失败');
          return usersResult;
        }
      }

      const testData = {
        userId: userId!,
        isBanned: false
      };

      console.log('解封数据:', testData);
      const result = await PUT_admin_permission(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试错误场景
    testAdminErrors: async () => {
      console.log('=== 测试管理员操作错误场景 ===');

      // 测试修改自己的权限
      console.log('1. 测试修改自己的权限...');
      const currentUser = JSON.parse(localStorage.getItem('mall_current_user') || 'null');
      if (currentUser) {
        let result = await PUT_admin_permission({
          userId: currentUser.id,
          isAdmin: false
        });
        console.log('结果:', result);
      }

      // 测试无效用户ID
      console.log('2. 测试无效用户ID...');
      let result = await PUT_admin_permission({
        userId: "invalid_user_id",
        isAdmin: true
      });
      console.log('结果:', result);

      // 测试空参数
      console.log('3. 测试空参数...');
      result = await PUT_admin_permission({
        userId: "some_id"
      });
      console.log('结果:', result);
    },

    // 完整管理员流程测试
    testAdminCompleteFlow: async () => {
      console.log('=== 测试管理员完整操作流程 ===');

      // 1. 获取用户列表
      console.log('1. 获取用户列表...');
      let result = await GET_admin_users();
      console.log('用户列表:', result);

      if (result.code === 200 && result.data?.users.length > 0) {
        // 找一个普通用户进行测试
        const normalUser = result.data.users.find(u => !u.isAdmin && !u.isBanned);

        if (normalUser) {
          console.log('找到测试用户:', normalUser.username);

          // 2. 设置为管理员
          console.log('2. 设置为管理员...');
          result = await PUT_admin_permission({
            userId: normalUser.id,
            isAdmin: true
          });
          console.log('设置管理员结果:', result);

          // 3. 封禁用户
          console.log('3. 封禁用户...');
          result = await PUT_admin_permission({
            userId: normalUser.id,
            isBanned: true
          });
          console.log('封禁结果:', result);

          // 4. 解封用户
          console.log('4. 解封用户...');
          result = await PUT_admin_permission({
            userId: normalUser.id,
            isBanned: false
          });
          console.log('解封结果:', result);

          // 5. 取消管理员权限
          console.log('5. 取消管理员权限...');
          result = await PUT_admin_permission({
            userId: normalUser.id,
            isAdmin: false
          });
          console.log('取消管理员结果:', result);
        } else {
          console.log('没有找到合适的测试用户');
        }
      }

      console.log('=== 管理员完整流程测试结束 ===');
    }
  };
}

// ===== 在浏览器控制台中的测试方法 =====

/*
// 首先需要以管理员身份登录
await window.testAuth.testLoginAdmin();

// === 普通用户功能测试 ===
// 测试获取用户信息
await window.testUser.testGetProfile();

// 测试更新用户信息
await window.testUser.testUpdateProfile();

// 测试地址管理
await window.testUser.testAddAddress();
await window.testUser.testGetAddresses();
await window.testUser.testDeleteAddress();

// 测试完整用户流程
await window.testUser.testCompleteFlow();

// === 管理员功能测试 ===
// 测试获取所有用户
await window.testAdmin.testGetAllUsers();

// 测试设置用户为管理员
await window.testAdmin.testSetUserAdmin();

// 测试封禁用户
await window.testAdmin.testBanUser();

// 测试解封用户
await window.testAdmin.testUnbanUser();

// 测试管理员错误场景
await window.testAdmin.testAdminErrors();

// 测试完整管理员流程
await window.testAdmin.testAdminCompleteFlow();

// === 手动调用API ===
// 手动更新用户权限
await window.testAPI.user.updateUserPermission({
  userId: "user_002",
  isAdmin: true,
  isBanned: false
});

// 手动获取用户列表
await window.testAPI.user.getAllUsers();

// 检查localStorage数据
console.log('当前用户:', JSON.parse(localStorage.getItem('mall_current_user')));
console.log('用户列表:', JSON.parse(localStorage.getItem('mall_users')));
*/

// 在main.tsx中添加商品API测试方法

import {
  GET_products,
  GET_product_detail,
  GET_hot_products,
  GET_categories,
  GET_admin_products,
  POST_admin_product,
  PUT_admin_product,
  DELETE_admin_product,
  POST_admin_category,
  PUT_admin_category,
  DELETE_admin_category
} from './shared/api/product';

// 在开发环境中扩展测试API
if (process.env.NODE_ENV === 'development') {
  // 扩展现有的testAPI对象
  (window as any).testAPI = {
    ...(window as any).testAPI,
    // 商品相关API测试
    product: {
      // 前台API
      getProducts: GET_products,
      getProductDetail: GET_product_detail,
      getHotProducts: GET_hot_products,
      getCategories: GET_categories,
      // 管理员API - 商品
      getAdminProducts: GET_admin_products,
      createProduct: POST_admin_product,
      updateProduct: PUT_admin_product,
      deleteProduct: DELETE_admin_product,
      // 管理员API - 分类
      createCategory: POST_admin_category,
      updateCategory: PUT_admin_category,
      deleteCategory: DELETE_admin_category
    }
  };

  // 前台商品功能测试
  (window as any).testProduct = {
    // 测试获取商品列表
    testGetProducts: async () => {
      console.log('=== 测试获取商品列表 ===');

      // 默认查询
      console.log('1. 默认查询...');
      let result = await GET_products();
      console.log('结果:', result);

      // 分页查询
      console.log('2. 分页查询...');
      result = await GET_products({ page: 1, pageSize: 5 });
      console.log('结果:', result);

      // 关键词搜索
      console.log('3. 关键词搜索...');
      result = await GET_products({ keyword: 'iPhone' });
      console.log('结果:', result);

      // 分类筛选
      console.log('4. 分类筛选...');
      result = await GET_products({ categoryId: 'cat_001' });
      console.log('结果:', result);

      // 排序
      console.log('5. 按价格排序...');
      result = await GET_products({ sortBy: 'price', sortOrder: 'asc' });
      console.log('结果:', result);

      return result;
    },

    // 测试获取商品详情
    testGetProductDetail: async (productId?: string) => {
      console.log('=== 测试获取商品详情 ===');

      if (!productId) {
        // 先获取商品列表，取第一个商品ID
        const productsResult = await GET_products({ pageSize: 1 });
        if (productsResult.code === 200 && productsResult.data?.products.length > 0) {
          productId = productsResult.data.products[0].id;
          console.log('使用商品ID:', productId);
        } else {
          console.log('没有找到商品');
          return { code: 400, message: '没有找到商品' };
        }
      }

      const result = await GET_product_detail(productId!);
      console.log('结果:', result);
      return result;
    },

    // 测试获取热门商品
    testGetHotProducts: async () => {
      console.log('=== 测试获取热门商品 ===');
      const result = await GET_hot_products();
      console.log('结果:', result);
      return result;
    },

    // 测试获取分类列表
    testGetCategories: async () => {
      console.log('=== 测试获取分类列表 ===');
      const result = await GET_categories();
      console.log('结果:', result);
      return result;
    },

    // 测试前台完整流程
    testFrontendFlow: async () => {
      console.log('=== 测试前台完整流程 ===');

      // 1. 获取分类
      console.log('1. 获取分类列表...');
      let result = await GET_categories();
      console.log('分类:', result);

      // 2. 获取热门商品
      console.log('2. 获取热门商品...');
      result = await GET_hot_products();
      console.log('热门商品:', result);

      // 3. 获取商品列表
      console.log('3. 获取商品列表...');
      result = await GET_products({ page: 1, pageSize: 10 });
      console.log('商品列表:', result);

      // 4. 获取商品详情
      if (result.code === 200 && result.data?.products.length > 0) {
        console.log('4. 获取商品详情...');
        const productId = result.data.products[0].id;
        result = await GET_product_detail(productId);
        console.log('商品详情:', result);
      }

      console.log('=== 前台流程测试结束 ===');
    }
  };

  // 管理员商品功能测试
  (window as any).testProductAdmin = {
    // 测试获取管理员商品列表
    testGetAdminProducts: async () => {
      console.log('=== 测试获取管理员商品列表 ===');

      // 获取所有商品（包括非激活的）
      const result = await GET_admin_products();
      console.log('结果:', result);
      return result;
    },

    // 测试添加商品
    testCreateProduct: async () => {
      console.log('=== 测试添加商品 ===');

      const testData = {
        name: "测试商品 " + Date.now(),
        description: "这是一个测试商品的详细描述",
        price: 999,
        originalPrice: 1299,
        coverImage: "https://picsum.photos/400/400?random=" + Date.now(),
        images: [
          "https://picsum.photos/800/800?random=" + Date.now(),
          "https://picsum.photos/800/800?random=" + (Date.now() + 1)
        ],
        categoryId: "cat_001",
        stock: 100
      };

      console.log('商品数据:', testData);
      const result = await POST_admin_product(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试更新商品
    testUpdateProduct: async (productId?: string) => {
      console.log('=== 测试更新商品 ===');

      if (!productId) {
        // 先获取商品列表，取第一个商品ID
        const productsResult = await GET_admin_products({ pageSize: 1 });
        if (productsResult.code === 200 && productsResult.data?.products.length > 0) {
          productId = productsResult.data.products[0].id;
          console.log('使用商品ID:', productId);
        } else {
          console.log('没有找到商品');
          return { code: 400, message: '没有找到商品' };
        }
      }

      const testData = {
        name: "更新后的商品名称 " + Date.now(),
        price: 1599,
        stock: 200
      };

      console.log('更新数据:', testData);
      const result = await PUT_admin_product(productId!, testData);
      console.log('结果:', result);
      return result;
    },

    // 测试删除商品
    testDeleteProduct: async (productId?: string) => {
      console.log('=== 测试删除商品 ===');

      if (!productId) {
        // 先获取商品列表，取最后一个商品ID
        const productsResult = await GET_admin_products();
        if (productsResult.code === 200 && productsResult.data?.products.length > 0) {
          const products = productsResult.data.products;
          productId = products[products.length - 1].id;
          console.log('使用商品ID:', productId);
        } else {
          console.log('没有找到商品');
          return { code: 400, message: '没有找到商品' };
        }
      }

      console.log('删除商品ID:', productId);
      const result = await DELETE_admin_product(productId!);
      console.log('结果:', result);
      return result;
    },

    // 测试分类管理
    testCreateCategory: async () => {
      console.log('=== 测试添加分类 ===');

      const testData = {
        name: "测试分类 " + Date.now(),
        icon: "🧪"
      };

      console.log('分类数据:', testData);
      const result = await POST_admin_category(testData);
      console.log('结果:', result);
      return result;
    },

    testUpdateCategory: async (categoryId?: string) => {
      console.log('=== 测试更新分类 ===');

      if (!categoryId) {
        // 先获取分类列表，取最后一个分类ID
        const categoriesResult = await GET_categories();
        if (categoriesResult.code === 200 && categoriesResult.data?.categories.length > 0) {
          const categories = categoriesResult.data.categories;
          categoryId = categories[categories.length - 1].id;
          console.log('使用分类ID:', categoryId);
        } else {
          console.log('没有找到分类');
          return { code: 400, message: '没有找到分类' };
        }
      }

      const testData = {
        name: "更新后的分类 " + Date.now(),
        icon: "🔄"
      };

      console.log('更新数据:', testData);
      const result = await PUT_admin_category(categoryId!, testData);
      console.log('结果:', result);
      return result;
    },

    testDeleteCategory: async (categoryId?: string) => {
      console.log('=== 测试删除分类 ===');

      if (!categoryId) {
        // 先获取分类列表，找一个没有商品的分类
        const categoriesResult = await GET_categories();
        if (categoriesResult.code === 200 && categoriesResult.data?.categories.length > 0) {
          // 这里简单取最后一个分类，实际使用中需要确保该分类下没有商品
          const categories = categoriesResult.data.categories;
          categoryId = categories[categories.length - 1].id;
          console.log('使用分类ID:', categoryId);
        } else {
          console.log('没有找到分类');
          return { code: 400, message: '没有找到分类' };
        }
      }

      console.log('删除分类ID:', categoryId);
      const result = await DELETE_admin_category(categoryId!);
      console.log('结果:', result);
      return result;
    },

    // 测试管理员错误场景
    testAdminErrors: async () => {
      console.log('=== 测试管理员操作错误场景 ===');

      // 测试添加商品缺少字段
      console.log('1. 测试添加商品缺少字段...');
      let result = await POST_admin_product({
        name: "",
        description: "测试",
        price: 100,
        coverImage: "",
        images: [],
        categoryId: "cat_001",
        stock: 10
      });
      console.log('结果:', result);

      // 测试无效价格
      console.log('2. 测试无效价格...');
      result = await POST_admin_product({
        name: "测试商品",
        description: "测试描述",
        price: -100,
        coverImage: "test.jpg",
        images: [],
        categoryId: "cat_001",
        stock: 10
      });
      console.log('结果:', result);

      // 测试无效分类ID
      console.log('3. 测试无效分类ID...');
      result = await POST_admin_product({
        name: "测试商品",
        description: "测试描述",
        price: 100,
        coverImage: "test.jpg",
        images: [],
        categoryId: "invalid_category",
        stock: 10
      });
      console.log('结果:', result);

      // 测试删除不存在的商品
      console.log('4. 测试删除不存在的商品...');
      result = await DELETE_admin_product("nonexistent_product");
      console.log('结果:', result);
    },

    // 测试完整管理员流程
    testAdminCompleteFlow: async () => {
      console.log('=== 测试管理员完整流程 ===');

      // 1. 添加分类
      console.log('1. 添加分类...');
      let result = await POST_admin_category({
        name: "流程测试分类 " + Date.now(),
        icon: "🔧"
      });
      console.log('添加分类结果:', result);
      const newCategoryId = result.data?.category?.id;

      // 2. 添加商品
      if (newCategoryId) {
        console.log('2. 添加商品...');
        result = await POST_admin_product({
          name: "流程测试商品 " + Date.now(),
          description: "这是流程测试商品",
          price: 299,
          originalPrice: 399,
          coverImage: "https://picsum.photos/400/400?random=" + Date.now(),
          images: ["https://picsum.photos/800/800?random=" + Date.now()],
          categoryId: newCategoryId,
          stock: 50
        });
        console.log('添加商品结果:', result);
        const newProductId = result.data?.product?.id;

        // 3. 更新商品
        if (newProductId) {
          console.log('3. 更新商品...');
          result = await PUT_admin_product(newProductId, {
            name: "更新后的流程测试商品",
            price: 399
          });
          console.log('更新商品结果:', result);

          // 4. 删除商品
          console.log('4. 删除商品...');
          result = await DELETE_admin_product(newProductId);
          console.log('删除商品结果:', result);
        }

        // 5. 删除分类（如果没有商品使用它）
        console.log('5. 删除分类...');
        result = await DELETE_admin_category(newCategoryId);
        console.log('删除分类结果:', result);
      }

      console.log('=== 管理员完整流程测试结束 ===');
    }
  };
}

// 在main.tsx中添加购物车API测试方法

import {
  GET_cart,
  POST_cart,
  PUT_cart_item,
  DELETE_cart_item,
  DELETE_cart,
  PUT_cart_selected
} from './shared/api/cart';

// 在开发环境中扩展测试API
if (process.env.NODE_ENV === 'development') {
  // 扩展现有的testAPI对象
  (window as any).testAPI = {
    ...(window as any).testAPI,
    // 购物车相关API测试
    cart: {
      getCart: GET_cart,
      addToCart: POST_cart,
      updateCartItem: PUT_cart_item,
      removeCartItem: DELETE_cart_item,
      clearCart: DELETE_cart,
      updateSelected: PUT_cart_selected
    }
  };

  // 购物车功能测试
  (window as any).testCart = {
    // 测试获取购物车
    testGetCart: async () => {
      console.log('=== 测试获取购物车 ===');
      const result = await GET_cart();
      console.log('结果:', result);
      return result;
    },

    // 测试添加商品到购物车
    testAddToCart: async (productId?: string, quantity = 1) => {
      console.log('=== 测试添加商品到购物车 ===');

      if (!productId) {
        // 调用商品API获取商品列表
        console.log('获取商品列表...');
        const productsResult = await window.testAPI.product.getProducts({ pageSize: 10 });
        if (productsResult.code === 200 && productsResult.data?.products.length > 0) {
          // 找一个有库存的商品
          const availableProduct = productsResult.data.products.find((p: any) => p.stock > 0);
          if (availableProduct) {
            productId = availableProduct.id;
            console.log('使用商品ID:', productId, '商品名:', availableProduct.name, '库存:', availableProduct.stock);
          } else {
            console.log('没有找到有库存的商品');
            return { code: 400, message: '没有找到有库存的商品' };
          }
        } else {
          console.log('获取商品列表失败:', productsResult);
          return { code: 400, message: '获取商品列表失败' };
        }
      }

      const testData = {
        productId: productId!,
        quantity: quantity
      };

      console.log('添加数据:', testData);
      const result = await POST_cart(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试更新购物车项数量
    testUpdateCartQuantity: async (cartItemId?: string, quantity = 2) => {
      console.log('=== 测试更新购物车项数量 ===');

      if (!cartItemId) {
        // 先获取购物车，取第一个项目
        const cartResult = await GET_cart();
        if (cartResult.code === 200 && cartResult.data?.cartItems.length > 0) {
          cartItemId = cartResult.data.cartItems[0].id;
          console.log('使用购物车项ID:', cartItemId);
        } else {
          console.log('购物车为空，先添加商品');
          await this.testAddToCart();
          const newCartResult = await GET_cart();
          if (newCartResult.code === 200 && newCartResult.data?.cartItems.length > 0) {
            cartItemId = newCartResult.data.cartItems[0].id;
          } else {
            return { code: 400, message: '无法获取购物车项' };
          }
        }
      }

      const testData = {
        quantity: quantity
      };

      console.log('更新数据:', testData);
      const result = await PUT_cart_item(cartItemId!, testData);
      console.log('结果:', result);
      return result;
    },

    // 测试更新购物车项选中状态
    testUpdateCartSelected: async (cartItemId?: string, selected = false) => {
      console.log('=== 测试更新购物车项选中状态 ===');

      if (!cartItemId) {
        // 先获取购物车，取第一个项目
        const cartResult = await GET_cart();
        if (cartResult.code === 200 && cartResult.data?.cartItems.length > 0) {
          cartItemId = cartResult.data.cartItems[0].id;
          console.log('使用购物车项ID:', cartItemId);
        } else {
          console.log('购物车为空');
          return { code: 400, message: '购物车为空' };
        }
      }

      const testData = {
        selected: selected
      };

      console.log('更新选中状态:', testData);
      const result = await PUT_cart_item(cartItemId!, testData);
      console.log('结果:', result);
      return result;
    },

    // 测试批量更新选中状态
    testBatchUpdateSelected: async (selected = true) => {
      console.log('=== 测试批量更新选中状态 ===');

      // 先获取购物车
      const cartResult = await GET_cart();
      if (cartResult.code !== 200 || !cartResult.data?.cartItems.length) {
        console.log('购物车为空');
        return { code: 400, message: '购物车为空' };
      }

      const cartItemIds = cartResult.data.cartItems.map(item => item.id);
      const testData = {
        cartItemIds: cartItemIds,
        selected: selected
      };

      console.log('批量更新数据:', testData);
      const result = await PUT_cart_selected(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试删除购物车项
    testRemoveCartItem: async (cartItemId?: string) => {
      console.log('=== 测试删除购物车项 ===');

      if (!cartItemId) {
        // 先获取购物车，取最后一个项目
        const cartResult = await GET_cart();
        if (cartResult.code === 200 && cartResult.data?.cartItems.length > 0) {
          const cartItems = cartResult.data.cartItems;
          cartItemId = cartItems[cartItems.length - 1].id;
          console.log('使用购物车项ID:', cartItemId);
        } else {
          console.log('购物车为空');
          return { code: 400, message: '购物车为空' };
        }
      }

      console.log('删除购物车项ID:', cartItemId);
      const result = await DELETE_cart_item(cartItemId!);
      console.log('结果:', result);
      return result;
    },

    // 测试清空购物车
    testClearCart: async () => {
      console.log('=== 测试清空购物车 ===');
      const result = await DELETE_cart();
      console.log('结果:', result);
      return result;
    },

    // 测试错误场景
    testCartErrors: async () => {
      console.log('=== 测试购物车错误场景 ===');

      // 测试添加不存在的商品
      console.log('1. 测试添加不存在的商品...');
      let result = await POST_cart({
        productId: "nonexistent_product",
        quantity: 1
      });
      console.log('结果:', result);

      // 测试添加负数数量
      console.log('2. 测试添加负数数量...');
      result = await POST_cart({
        productId: "prod_001",
        quantity: -1
      });
      console.log('结果:', result);

      // 测试更新不存在的购物车项
      console.log('3. 测试更新不存在的购物车项...');
      result = await PUT_cart_item("nonexistent_cart_item", {
        quantity: 2
      });
      console.log('结果:', result);

      // 测试删除不存在的购物车项
      console.log('4. 测试删除不存在的购物车项...');
      result = await DELETE_cart_item("nonexistent_cart_item");
      console.log('结果:', result);
    },

    // 测试完整购物车流程
    testCartCompleteFlow: async () => {
      console.log('=== 测试购物车完整流程 ===');

      // 1. 清空购物车
      console.log('1. 清空购物车...');
      await DELETE_cart();

      // 2. 查看空购物车
      console.log('2. 查看空购物车...');
      let result = await GET_cart();
      console.log('空购物车:', result);

      // 3. 添加多个商品
      console.log('3. 添加多个商品...');
      const products = JSON.parse(localStorage.getItem('mall_products') || '[]');
      if (products.length >= 2) {
        // 添加第一个商品
        result = await POST_cart({
          productId: products[0].id,
          quantity: 2
        });
        console.log('添加第一个商品:', result);

        // 添加第二个商品
        result = await POST_cart({
          productId: products[1].id,
          quantity: 1
        });
        console.log('添加第二个商品:', result);

        // 再次添加第一个商品（测试数量累加）
        result = await POST_cart({
          productId: products[0].id,
          quantity: 1
        });
        console.log('再次添加第一个商品:', result);
      }

      // 4. 查看购物车
      console.log('4. 查看购物车...');
      result = await GET_cart();
      console.log('购物车内容:', result);

      if (result.code === 200 && result.data?.cartItems.length > 0) {
        const cartItems = result.data.cartItems;

        // 5. 更新第一个商品数量
        console.log('5. 更新第一个商品数量...');
        result = await PUT_cart_item(cartItems[0].id, {
          quantity: 5
        });
        console.log('更新数量结果:', result);

        // 6. 取消选中第一个商品
        console.log('6. 取消选中第一个商品...');
        result = await PUT_cart_item(cartItems[0].id, {
          selected: false
        });
        console.log('取消选中结果:', result);

        // 7. 批量选中所有商品
        console.log('7. 批量选中所有商品...');
        const cartItemIds = cartItems.map(item => item.id);
        result = await PUT_cart_selected({
          cartItemIds: cartItemIds,
          selected: true
        });
        console.log('批量选中结果:', result);

        // 8. 查看最终购物车状态
        console.log('8. 查看最终购物车状态...');
        result = await GET_cart();
        console.log('最终购物车:', result);

        // 9. 删除最后一个商品
        console.log('9. 删除最后一个商品...');
        const lastItem = cartItems[cartItems.length - 1];
        result = await DELETE_cart_item(lastItem.id);
        console.log('删除结果:', result);

        // 10. 查看删除后的购物车
        console.log('10. 查看删除后的购物车...');
        result = await GET_cart();
        console.log('删除后购物车:', result);
      }

      console.log('=== 购物车完整流程测试结束 ===');
    },

    // 测试库存检查
    testStockValidation: async () => {
      console.log('=== 测试库存检查 ===');

      const products = JSON.parse(localStorage.getItem('mall_products') || '[]');
      if (products.length === 0) {
        console.log('没有商品数据');
        return;
      }

      const product = products[0];
      console.log('测试商品:', product.name, '库存:', product.stock);

      // 1. 添加正常数量
      console.log('1. 添加正常数量...');
      let result = await POST_cart({
        productId: product.id,
        quantity: Math.min(2, product.stock)
      });
      console.log('结果:', result);

      // 2. 尝试添加超过库存的数量
      console.log('2. 尝试添加超过库存的数量...');
      result = await POST_cart({
        productId: product.id,
        quantity: product.stock + 10
      });
      console.log('结果:', result);

      // 3. 获取购物车，测试更新为超过库存的数量
      const cartResult = await GET_cart();
      if (cartResult.code === 200 && cartResult.data?.cartItems.length > 0) {
        const cartItem = cartResult.data.cartItems.find(item => item.productId === product.id);
        if (cartItem) {
          console.log('3. 尝试更新为超过库存的数量...');
          result = await PUT_cart_item(cartItem.id, {
            quantity: product.stock + 5
          });
          console.log('结果:', result);
        }
      }
    }
  };
}

// ===== 在浏览器控制台中的测试方法 =====

/*
// 首先需要登录
await window.testAuth.testLoginAdmin();

// === 基础功能测试 ===
// 测试获取购物车
await window.testCart.testGetCart();

// 测试添加商品到购物车
await window.testCart.testAddToCart();

// 测试更新购物车项数量
await window.testCart.testUpdateCartQuantity();

// 测试更新选中状态
await window.testCart.testUpdateCartSelected();

// 测试批量更新选中状态
await window.testCart.testBatchUpdateSelected();

// 测试删除购物车项
await window.testCart.testRemoveCartItem();

// 测试清空购物车
await window.testCart.testClearCart();

// === 完整流程测试 ===
// 测试完整购物车流程
await window.testCart.testCartCompleteFlow();

// 测试库存验证
await window.testCart.testStockValidation();

// 测试错误场景
await window.testCart.testCartErrors();

// === 手动调用API ===
// 手动添加商品到购物车
await window.testAPI.cart.addToCart({
  productId: "prod_001",
  quantity: 2
});

// 手动更新购物车项
await window.testAPI.cart.updateCartItem("cart_item_id", {
  quantity: 3,
  selected: true
});

// 手动批量更新选中状态
await window.testAPI.cart.updateSelected({
  cartItemIds: ["cart_item_1", "cart_item_2"],
  selected: false
});

// 检查localStorage数据
console.log('购物车数据:', JSON.parse(localStorage.getItem('mall_cart_items')));
console.log('当前用户:', JSON.parse(localStorage.getItem('mall_current_user')));

// === 购物车统计信息测试 ===
// 查看详细的购物车统计
const cartResult = await window.testAPI.cart.getCart();
if (cartResult.code === 200) {
  console.log('购物车统计:', {
    商品总数: cartResult.data.totalQuantity,
    选中商品数: cartResult.data.selectedQuantity,
    总金额: cartResult.data.totalAmount,
    选中金额: cartResult.data.selectedAmount,
    商品列表: cartResult.data.cartItems
  });
}
*/

// 在main.tsx中添加订单API测试方法

import {
  GET_orders,
  GET_order_detail,
  POST_order,
  PUT_order_pay,
  DELETE_order
} from './shared/api/order';

// 在开发环境中扩展测试API
if (process.env.NODE_ENV === 'development') {
  // 扩展现有的testAPI对象
  (window as any).testAPI = {
    ...(window as any).testAPI,
    // 订单相关API测试
    order: {
      getOrders: GET_orders,
      getOrderDetail: GET_order_detail,
      createOrder: POST_order,
      payOrder: PUT_order_pay,
      cancelOrder: DELETE_order
    }
  };

  // 订单功能测试
  (window as any).testOrder = {
    // 测试获取订单列表
    testGetOrders: async () => {
      console.log('=== 测试获取订单列表 ===');

      // 默认查询
      console.log('1. 默认查询...');
      let result = await GET_orders();
      console.log('结果:', result);

      // 分页查询
      console.log('2. 分页查询...');
      result = await GET_orders({ page: 1, pageSize: 5 });
      console.log('结果:', result);

      // 按状态筛选
      console.log('3. 查询待支付订单...');
      result = await GET_orders({ status: 'pending' });
      console.log('结果:', result);

      console.log('4. 查询已完成订单...');
      result = await GET_orders({ status: 'completed' });
      console.log('结果:', result);

      console.log('5. 查询已取消订单...');
      result = await GET_orders({ status: 'cancelled' });
      console.log('结果:', result);

      return result;
    },

    // 测试获取订单详情
    testGetOrderDetail: async (orderId?: string) => {
      console.log('=== 测试获取订单详情 ===');

      if (!orderId) {
        // 先获取订单列表，取第一个订单
        const ordersResult = await GET_orders({ pageSize: 1 });
        if (ordersResult.code === 200 && ordersResult.data?.orders.length > 0) {
          orderId = ordersResult.data.orders[0].id;
          console.log('使用订单ID:', orderId);
        } else {
          console.log('没有找到订单');
          return { code: 400, message: '没有找到订单' };
        }
      }

      const result = await GET_order_detail(orderId!);
      console.log('结果:', result);
      return result;
    },

    // 测试从购物车创建订单
    testCreateOrderFromCart: async (addressId?: string) => {
      console.log('=== 测试从购物车创建订单 ===');

      // 获取地址ID
      if (!addressId) {
        const addresses = JSON.parse(localStorage.getItem('mall_addresses') || '[]');
        const currentUser = JSON.parse(localStorage.getItem('mall_current_user') || 'null');
        if (currentUser && addresses.length > 0) {
          const userAddress = addresses.find((addr: any) => addr.userId === currentUser.id);
          if (userAddress) {
            addressId = userAddress.id;
            console.log('使用地址ID:', addressId);
          } else {
            console.log('没有找到用户地址');
            return { code: 400, message: '没有找到用户地址' };
          }
        } else {
          console.log('没有地址数据');
          return { code: 400, message: '没有地址数据' };
        }
      }

      // 获取购物车中选中的商品
      const cartResult = await window.testAPI.cart.getCart();
      if (cartResult.code !== 200 || !cartResult.data?.cartItems.length) {
        console.log('购物车为空，先添加商品...');
        await window.testCart.testAddToCart();
        const newCartResult = await window.testAPI.cart.getCart();
        if (newCartResult.code !== 200 || !newCartResult.data?.cartItems.length) {
          return { code: 400, message: '购物车仍为空' };
        }
      }

      // 获取最新购物车
      const finalCartResult = await window.testAPI.cart.getCart();
      const selectedItems = finalCartResult.data.cartItems.filter((item: any) => item.selected);

      if (selectedItems.length === 0) {
        console.log('没有选中的商品，先选中所有商品...');
        const allItemIds = finalCartResult.data.cartItems.map((item: any) => item.id);
        await window.testAPI.cart.updateSelected({
          cartItemIds: allItemIds,
          selected: true
        });
      }

      // 重新获取购物车
      const updatedCartResult = await window.testAPI.cart.getCart();
      const cartItemIds = updatedCartResult.data.cartItems
        .filter((item: any) => item.selected)
        .map((item: any) => item.id);

      console.log('选中的购物车项:', cartItemIds);

      const testData = {
        addressId: addressId!,
        cartItemIds: cartItemIds
      };

      console.log('创建订单数据:', testData);
      const result = await POST_order(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试直接购买创建订单
    testCreateOrderDirect: async (addressId?: string, productId?: string, quantity = 2) => {
      console.log('=== 测试直接购买创建订单 ===');

      // 获取地址ID
      if (!addressId) {
        const addresses = JSON.parse(localStorage.getItem('mall_addresses') || '[]');
        const currentUser = JSON.parse(localStorage.getItem('mall_current_user') || 'null');
        if (currentUser && addresses.length > 0) {
          const userAddress = addresses.find((addr: any) => addr.userId === currentUser.id);
          if (userAddress) {
            addressId = userAddress.id;
            console.log('使用地址ID:', addressId);
          }
        }
      }

      // 获取商品ID
      if (!productId) {
        const products = JSON.parse(localStorage.getItem('mall_products') || '[]');
        if (products.length > 0) {
          productId = products[0].id;
          console.log('使用商品ID:', productId, '商品名:', products[0].name);
        }
      }

      if (!addressId || !productId) {
        return { code: 400, message: '缺少地址或商品信息' };
      }

      const testData = {
        addressId: addressId!,
        directItems: [
          {
            productId: productId!,
            quantity: quantity
          }
        ]
      };

      console.log('直接购买数据:', testData);
      const result = await POST_order(testData);
      console.log('结果:', result);
      return result;
    },

    // 测试支付订单
    testPayOrder: async (orderId?: string) => {
      console.log('=== 测试支付订单 ===');

      if (!orderId) {
        // 先获取待支付的订单
        const ordersResult = await GET_orders({ status: 'pending' });
        if (ordersResult.code === 200 && ordersResult.data?.orders.length > 0) {
          orderId = ordersResult.data.orders[0].id;
          console.log('使用订单ID:', orderId);
        } else {
          console.log('没有找到待支付订单，先创建一个...');
          const createResult = await window.testOrder.testCreateOrderDirect();
          if (createResult.code === 200) {
            orderId = createResult.data.order.id;
          } else {
            return { code: 400, message: '无法创建订单' };
          }
        }
      }

      console.log('支付订单ID:', orderId);
      const result = await PUT_order_pay(orderId!);
      console.log('结果:', result);
      return result;
    },

    // 测试取消订单
    testCancelOrder: async (orderId?: string) => {
      console.log('=== 测试取消订单 ===');

      if (!orderId) {
        // 先获取待支付的订单
        const ordersResult = await GET_orders({ status: 'pending' });
        if (ordersResult.code === 200 && ordersResult.data?.orders.length > 0) {
          orderId = ordersResult.data.orders[0].id;
          console.log('使用订单ID:', orderId);
        } else {
          console.log('没有找到待支付订单，先创建一个...');
          const createResult = await window.testOrder.testCreateOrderDirect();
          if (createResult.code === 200) {
            orderId = createResult.data.order.id;
          } else {
            return { code: 400, message: '无法创建订单' };
          }
        }
      }

      console.log('取消订单ID:', orderId);
      const result = await DELETE_order(orderId!);
      console.log('结果:', result);
      return result;
    },

    // 测试订单错误场景
    testOrderErrors: async () => {
      console.log('=== 测试订单错误场景 ===');

      // 测试创建订单缺少地址
      console.log('1. 测试创建订单缺少地址...');
      let result = await POST_order({
        addressId: "",
        directItems: [
          {
            productId: "prod_001",
            quantity: 1
          }
        ]
      });
      console.log('结果:', result);

      // 测试创建订单商品不存在
      console.log('2. 测试创建订单商品不存在...');
      const addresses = JSON.parse(localStorage.getItem('mall_addresses') || '[]');
      const currentUser = JSON.parse(localStorage.getItem('mall_current_user') || 'null');
      let addressId = '';
      if (currentUser && addresses.length > 0) {
        const userAddress = addresses.find((addr: any) => addr.userId === currentUser.id);
        if (userAddress) {
          addressId = userAddress.id;
        }
      }

      if (addressId) {
        result = await POST_order({
          addressId: addressId,
          directItems: [
            {
              productId: "nonexistent_product",
              quantity: 1
            }
          ]
        });
        console.log('结果:', result);
      }

      // 测试支付不存在的订单
      console.log('3. 测试支付不存在的订单...');
      result = await PUT_order_pay("nonexistent_order");
      console.log('结果:', result);

      // 测试取消不存在的订单
      console.log('4. 测试取消不存在的订单...');
      result = await DELETE_order("nonexistent_order");
      console.log('结果:', result);
    },

    // 测试库存管理
    testStockManagement: async () => {
      console.log('=== 测试库存管理 ===');

      // 0. 确保用户有地址
      console.log('0. 检查并准备用户地址...');
      const addresses = JSON.parse(localStorage.getItem('mall_addresses') || '[]');
      const currentUser = JSON.parse(localStorage.getItem('mall_current_user') || 'null');

      if (!currentUser) {
        console.log('用户未登录');
        return { code: 401, message: '用户未登录' };
      }

      let userAddress = addresses.find((addr: any) => addr.userId === currentUser.id);
      if (!userAddress) {
        console.log('用户没有地址，先添加地址...');
        const addAddressResult = await window.testUser.testAddAddress();
        if (addAddressResult.code !== 200) {
          console.log('添加地址失败:', addAddressResult);
          return addAddressResult;
        }
        // 重新获取地址
        const updatedAddresses = JSON.parse(localStorage.getItem('mall_addresses') || '[]');
        userAddress = updatedAddresses.find((addr: any) => addr.userId === currentUser.id);
      }

      if (!userAddress) {
        console.log('无法获取用户地址');
        return { code: 400, message: '无法获取用户地址' };
      }

      console.log('使用地址:', userAddress.receiverName, '-', userAddress.fullAddress);

      // 1. 查看商品库存
      const products = JSON.parse(localStorage.getItem('mall_products') || '[]');
      if (products.length === 0) {
        console.log('没有商品数据');
        return;
      }

      const testProduct = products[0];
      console.log('测试商品:', testProduct.name, '初始库存:', testProduct.stock, '初始销量:', testProduct.sales);

      // 2. 创建订单（扣减库存）
      console.log('2. 创建订单扣减库存...');
      const createResult = await window.testOrder.testCreateOrderDirect(userAddress.id, testProduct.id, 2);
      console.log('创建订单结果:', createResult);

      if (createResult.code === 200) {
        // 检查库存是否减少
        const updatedProducts = JSON.parse(localStorage.getItem('mall_products') || '[]');
        const updatedProduct = updatedProducts.find((p: any) => p.id === testProduct.id);
        console.log('订单创建后库存:', updatedProduct?.stock, '销量:', updatedProduct?.sales);

        // 3. 取消订单（恢复库存）
        console.log('3. 取消订单恢复库存...');
        const cancelResult = await DELETE_order(createResult.data.order.id);
        console.log('取消订单结果:', cancelResult);

        // 检查库存是否恢复
        const restoredProducts = JSON.parse(localStorage.getItem('mall_products') || '[]');
        const restoredProduct = restoredProducts.find((p: any) => p.id === testProduct.id);
        console.log('订单取消后库存:', restoredProduct?.stock, '销量:', restoredProduct?.sales);

        // 4. 再次创建订单并支付（增加销量）
        console.log('4. 创建订单并支付...');
        const payCreateResult = await window.testOrder.testCreateOrderDirect(userAddress.id, testProduct.id, 1);
        if (payCreateResult.code === 200) {
          const payResult = await PUT_order_pay(payCreateResult.data.order.id);
          console.log('支付结果:', payResult);

          // 检查销量是否增加
          const finalProducts = JSON.parse(localStorage.getItem('mall_products') || '[]');
          const finalProduct = finalProducts.find((p: any) => p.id === testProduct.id);
          console.log('支付后库存:', finalProduct?.stock, '销量:', finalProduct?.sales);
        }
      }
    },

    // 测试完整订单流程
    testOrderCompleteFlow: async () => {
      console.log('=== 测试完整订单流程 ===');

      // 1. 获取初始订单列表
      console.log('1. 获取初始订单列表...');
      let result = await GET_orders();
      console.log('初始订单数量:', result.data?.orders.length || 0);

      // 2. 清空购物车，添加商品
      console.log('2. 准备购物车...');
      await window.testCart.testClearCart();
      await window.testCart.testAddToCart();

      // 3. 从购物车创建订单
      console.log('3. 从购物车创建订单...');
      const cartOrderResult = await window.testOrder.testCreateOrderFromCart();
      console.log('购物车订单结果:', cartOrderResult);

      // 4. 直接购买创建订单
      console.log('4. 直接购买创建订单...');
      const directOrderResult = await window.testOrder.testCreateOrderDirect();
      console.log('直接购买订单结果:', directOrderResult);

      // 5. 查看待支付订单
      console.log('5. 查看待支付订单...');
      result = await GET_orders({ status: 'pending' });
      console.log('待支付订单:', result);

      if (result.code === 200 && result.data?.orders.length >= 2) {
        const orders = result.data.orders;

        // 6. 支付第一个订单
        console.log('6. 支付第一个订单...');
        const payResult = await PUT_order_pay(orders[0].id);
        console.log('支付结果:', payResult);

        // 7. 取消第二个订单
        console.log('7. 取消第二个订单...');
        const cancelResult = await DELETE_order(orders[1].id);
        console.log('取消结果:', cancelResult);

        // 8. 查看各状态订单
        console.log('8. 查看各状态订单...');
        const pendingOrders = await GET_orders({ status: 'pending' });
        const completedOrders = await GET_orders({ status: 'completed' });
        const cancelledOrders = await GET_orders({ status: 'cancelled' });

        console.log('待支付订单数:', pendingOrders.data?.orders.length || 0);
        console.log('已完成订单数:', completedOrders.data?.orders.length || 0);
        console.log('已取消订单数:', cancelledOrders.data?.orders.length || 0);

        // 9. 查看订单详情
        if (payResult.code === 200) {
          console.log('9. 查看已支付订单详情...');
          const detailResult = await GET_order_detail(payResult.data.order.id);
          console.log('订单详情:', detailResult);
        }
      }

      console.log('=== 完整订单流程测试结束 ===');
    }
  };
}

// ===== 在浏览器控制台中的测试方法 =====

/*
// 首先需要登录
await window.testAuth.testLoginAdmin();

// 确保有地址数据
await window.testUser.testAddAddress();

// === 基础功能测试 ===
// 测试获取订单列表
await window.testOrder.testGetOrders();

// 测试获取订单详情
await window.testOrder.testGetOrderDetail();

// 测试从购物车创建订单
await window.testOrder.testCreateOrderFromCart();

// 测试直接购买创建订单
await window.testOrder.testCreateOrderDirect();

// 测试支付订单
await window.testOrder.testPayOrder();

// 测试取消订单
await window.testOrder.testCancelOrder();

// === 高级功能测试 ===
// 测试库存管理
await window.testOrder.testStockManagement();

// 测试完整订单流程
await window.testOrder.testOrderCompleteFlow();

// 测试错误场景
await window.testOrder.testOrderErrors();

// === 手动调用API ===
// 手动创建订单
await window.testAPI.order.createOrder({
  addressId: "addr_001",
  directItems: [
    {
      productId: "prod_001",
      quantity: 2
    }
  ]
});

// 手动支付订单
await window.testAPI.order.payOrder("ORD20241201-ABC123");

// 手动取消订单
await window.testAPI.order.cancelOrder("ORD20241201-ABC123");

// 检查localStorage数据
console.log('订单数据:', JSON.parse(localStorage.getItem('mall_orders')));
console.log('商品库存变化:', JSON.parse(localStorage.getItem('mall_products')));

// === 订单状态流转测试 ===
// 创建 -> 支付 -> 完成
const order1 = await window.testOrder.testCreateOrderDirect();
if (order1.code === 200) {
  console.log('订单状态:', order1.data.order.status); // pending
  const paid = await window.testAPI.order.payOrder(order1.data.order.id);
  console.log('支付后状态:', paid.data.order.status); // completed
}

// 创建 -> 取消 -> 已取消
const order2 = await window.testOrder.testCreateOrderDirect();
if (order2.code === 200) {
  console.log('订单状态:', order2.data.order.status); // pending
  const cancelled = await window.testAPI.order.cancelOrder(order2.data.order.id);
  console.log('取消后状态:', cancelled.data.order.status); // cancelled
}
*/

// 在main.tsx中添加系统API测试方法

import { GET_banners } from './shared/api/system';

// 在开发环境中扩展测试API
if (process.env.NODE_ENV === 'development') {
  // 扩展现有的testAPI对象
  (window as any).testAPI = {
    ...(window as any).testAPI,
    // 系统相关API测试
    system: {
      getBanners: GET_banners
    }
  };

  // 系统功能测试
  (window as any).testSystem = {
    // 测试获取轮播图
    testGetBanners: async () => {
      console.log('=== 测试获取轮播图 ===');
      const result = await GET_banners();
      console.log('结果:', result);

      if (result.code === 200 && result.data?.banners) {
        console.log('轮播图数量:', result.data.banners.length);
        result.data.banners.forEach((banner: any, index: number) => {
          console.log(`轮播图 ${index + 1}:`, {
            标题: banner.title,
            排序: banner.sort,
            链接类型: banner.linkType,
            链接值: banner.linkValue,
            图片: banner.image
          });
        });
      }

      return result;
    },

    // 测试轮播图排序
    testBannerSorting: async () => {
      console.log('=== 测试轮播图排序 ===');
      const result = await GET_banners();

      if (result.code === 200 && result.data?.banners) {
        const banners = result.data.banners;
        console.log('轮播图按排序权重排列:');

        banners.forEach((banner: any, index: number) => {
          console.log(`第${index + 1}位: ${banner.title} (sort: ${banner.sort})`);
        });

        // 验证排序是否正确
        let isSorted = true;
        for (let i = 1; i < banners.length; i++) {
          if (banners[i - 1].sort > banners[i].sort) {
            isSorted = false;
            break;
          }
        }

        console.log('排序是否正确:', isSorted ? '✅ 是' : '❌ 否');
      }

      return result;
    },

    // 验证轮播图数据完整性
    testBannerDataIntegrity: async () => {
      console.log('=== 验证轮播图数据完整性 ===');
      const result = await GET_banners();

      if (result.code === 200 && result.data?.banners) {
        const banners = result.data.banners;
        let allValid = true;

        banners.forEach((banner: any, index: number) => {
          const issues = [];

          if (!banner.id) issues.push('缺少ID');
          if (!banner.title) issues.push('缺少标题');
          if (!banner.image) issues.push('缺少图片');
          if (!banner.linkType) issues.push('缺少链接类型');
          if (!banner.linkValue) issues.push('缺少链接值');
          if (typeof banner.sort !== 'number') issues.push('排序字段不是数字');
          if (!['product', 'category'].includes(banner.linkType)) {
            issues.push('链接类型无效');
          }

          if (issues.length > 0) {
            console.log(`轮播图 ${index + 1} "${banner.title}" 存在问题:`, issues);
            allValid = false;
          } else {
            console.log(`轮播图 ${index + 1} "${banner.title}" ✅ 数据完整`);
          }
        });

        console.log('数据完整性检查:', allValid ? '✅ 通过' : '❌ 存在问题');
      }

      return result;
    },

    // 测试轮播图链接验证
    testBannerLinks: async () => {
      console.log('=== 测试轮播图链接验证 ===');
      const result = await GET_banners();

      if (result.code === 200 && result.data?.banners) {
        const banners = result.data.banners;

        // 获取商品和分类数据用于验证
        const products = JSON.parse(localStorage.getItem('mall_products') || '[]');
        const categories = JSON.parse(localStorage.getItem('mall_categories') || '[]');

        for (const banner of banners) {
          console.log(`验证轮播图 "${banner.title}" 的链接...`);

          if (banner.linkType === 'product') {
            const product = products.find((p: any) => p.id === banner.linkValue);
            if (product) {
              console.log(`  ✅ 链接到商品: ${product.name}`);
            } else {
              console.log(`  ❌ 商品不存在: ${banner.linkValue}`);
            }
          } else if (banner.linkType === 'category') {
            const category = categories.find((c: any) => c.id === banner.linkValue);
            if (category) {
              console.log(`  ✅ 链接到分类: ${category.name}`);
            } else {
              console.log(`  ❌ 分类不存在: ${banner.linkValue}`);
            }
          }
        }
      }

      return result;
    },

    // 模拟首页场景测试
    testHomepageScenario: async () => {
      console.log('=== 模拟首页场景测试 ===');

      console.log('模拟首页加载轮播图...');
      const bannersResult = await GET_banners();

      if (bannersResult.code === 200) {
        const banners = bannersResult.data.banners;

        console.log('✅ 轮播图加载成功');
        console.log(`📊 获取到 ${banners.length} 个轮播图`);

        // 模拟用户点击轮播图
        if (banners.length > 0) {
          const firstBanner = banners[0];
          console.log(`\n🖱️ 模拟用户点击轮播图: "${firstBanner.title}"`);
          console.log(`📍 跳转类型: ${firstBanner.linkType}`);
          console.log(`🔗 跳转目标: ${firstBanner.linkValue}`);

          if (firstBanner.linkType === 'product') {
            // 模拟跳转到商品详情
            console.log('🛍️ 模拟跳转到商品详情页...');
            const productResult = await window.testAPI.product.getProductDetail(firstBanner.linkValue);
            if (productResult.code === 200) {
              console.log(`✅ 成功加载商品: ${productResult.data.product.name}`);
            } else {
              console.log('❌ 商品加载失败:', productResult.message);
            }
          } else if (firstBanner.linkType === 'category') {
            // 模拟跳转到分类页
            console.log('📂 模拟跳转到分类页...');
            const productsResult = await window.testAPI.product.getProducts({
              categoryId: firstBanner.linkValue,
              pageSize: 5
            });
            if (productsResult.code === 200) {
              console.log(`✅ 成功加载分类商品: ${productsResult.data.products.length} 个`);
            } else {
              console.log('❌ 分类商品加载失败:', productsResult.message);
            }
          }
        }
      } else {
        console.log('❌ 轮播图加载失败:', bannersResult.message);
      }

      return bannersResult;
    }
  };
}

// ===== 在浏览器控制台中的测试方法 =====

/*
// === 基础功能测试 ===
// 测试获取轮播图
await window.testSystem.testGetBanners();

// 测试轮播图排序
await window.testSystem.testBannerSorting();

// 验证数据完整性
await window.testSystem.testBannerDataIntegrity();

// 测试轮播图链接验证
await window.testSystem.testBannerLinks();

// === 场景测试 ===
// 模拟首页场景
await window.testSystem.testHomepageScenario();

// === 手动调用API ===
// 直接获取轮播图
const banners = await window.testAPI.system.getBanners();
console.log('轮播图数据:', banners);

// === 轮播图使用示例 ===
// 获取轮播图并显示基本信息
const result = await window.testAPI.system.getBanners();
if (result.code === 200) {
  result.data.banners.forEach((banner, index) => {
    console.log(`轮播图${index + 1}:`, {
      标题: banner.title,
      图片: banner.image,
      排序: banner.sort,
      '点击跳转': `${banner.linkType} - ${banner.linkValue}`
    });
  });
}

// 检查localStorage数据
console.log('轮播图原始数据:', JSON.parse(localStorage.getItem('mall_banners')));
*/
//开发环境使用

// 声明全局变量
declare const __PROJECT_TYPE__: string

const loadApp = async () => {
  try {
    // 先初始化数据
    console.log('开始初始化商城数据...')
    await initializeData()
    console.log('数据初始化完成！')

    // 动态导入项目组件
    const { default: MallApp } = await import('./projects/mall/App')
    const { default: AdminApp } = await import('./projects/admin/App')

    const App: React.FC = () => {
      return (
        <Router>
          <Routes>
            {/* 前台商城路由 */}
            <Route path="/mall/*" element={<MallApp />} />

            {/* 后台管理路由 */}
            <Route path="/admin/*" element={<AdminApp />} />

            {/* 默认重定向到前台商城 */}
            <Route path="/" element={<Navigate to="/mall" replace />} />

            {/* 其他路径重定向到前台商城 */}
            <Route path="*" element={<Navigate to="/mall" replace />} />
          </Routes>
        </Router>
      )
    }

    const root = ReactDOM.createRoot(
      document.getElementById('root') as HTMLElement
    )

    root.render(
      <React.StrictMode>
        <App />
      </React.StrictMode>
    )
  } catch (error) {
    console.error('应用启动失败:', error)

    // 初始化失败时显示错误信息
    document.getElementById('root')!.innerHTML = `
      <div style="
        display: flex; 
        justify-content: center; 
        align-items: center; 
        height: 100vh; 
        font-family: Arial, sans-serif;
        background-color: #f5f5f5;
      ">
        <div style="
          text-align: center; 
          padding: 2rem; 
          background: white; 
          border-radius: 8px; 
          box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        ">
          <h2 style="color: #ff4d4f; margin-bottom: 1rem;">应用初始化失败</h2>
          <p style="margin-bottom: 1rem; color: #666;">
            ${error instanceof Error ? error.message : '未知错误'}
          </p>
          <button 
            onclick="window.location.reload()" 
            style="
              background: #1890ff; 
              color: white; 
              border: none; 
              padding: 0.5rem 1rem; 
              border-radius: 4px; 
              cursor: pointer;
            "
          >
            刷新页面
          </button>
        </div>
      </div>
    `
  }
}

loadApp()